package com.nix.control;


import com.nix.maze.Direction;
import com.nix.maze.Lattice;
import com.nix.maze.Map;
import com.nix.role.Dragon;
import com.nix.role.HistoryRecord;
import com.nix.role.Role;

import java.util.ArrayList;

/**
 * @author zhangpei
 * @Email zhangpe0312@qq.com
 * @day 2017/12/4 15:10
 * @Use 角色移动解决方法
 */
public class Move {
    /**
     * 上移动
     */
    public final static int UP = 0;
    /**
     * 下移动
     */
    public final static int DOWN = 2;
    /**
     * 左移动
     */
    public final static int LEFT = 3;
    /**
     * 右移动
     */
    public final static int RIGHT = 1;
    /**
     * 射击动作
     */
    public final static int SHOOTING = 4;

    /**
     * 角色移动实现
     *
     * @param move
     */
    public static void roleMove(int move, Map map) {
        switch (move) {
            case UP:
                setUp(map);
                break;
            case DOWN:
                setDOWN(map);
                break;
            case LEFT:
                setLEFT(map);
                break;
            case RIGHT:
                setRIGHT(map);
                break;
            case SHOOTING:setSHOOTING(map);
                break;
            case -2:break;
            default:
                System.out.println("操作无效！请重新输入命令：");
        }
    }

    /**
     * 射击动作
     *设定射击离角色距离最短的那个怪物，并角色转向这个位置
     * @param map      操作的地图
     */
    private static void setSHOOTING(Map map) {
        System.out.println("进入了 SHOOTING - -> ");
        ArrayList<Lattice> lattices  = findMonsters(map,6);
        ArrayList<Lattice> Maplattices  = map.getMap();
        double minDistance = 1000000;
        int x = -1,y = -1;
        if (lattices!= null&&lattices.size()!=0) {
            System.out.println(" 周围有 " + lattices.size() + " 个怪物");
             for(Lattice lattice : lattices){
                  if(minDistance>distance(lattice)){
                      minDistance = distance(lattice);
                      x = lattice.getxAddress();
                      y = lattice.getyAddress();
                  }
             }
            for (int i = 0; i <Maplattices.size() ; i++) {
                 //找到这个怪物，并消灭，子弹减一
                if(Maplattices.get(i).getxAddress()==x&&Maplattices.get(i).getyAddress()==y){
                    shooting();
                    Maplattices.get(i).setClasszz(Map.LATTICE);
                    Maplattices.get(i).setValue(Map.setValue(Map.isNull));
                    //设置角色的方位和怪物方位买面对面
                    Role.direction = Direction.getPostion(Maplattices.get(i).getDirection(),Direction.SOUTH);
                    System.out.println("坐标为 ： x = " + x + "  y = "+ y + " 的怪物被你消灭了" );
                }
            }
        } else {
            System.out.println("周围无怪物，操作无效！");
        }
    }

    private static double distance(Lattice findLattice){
        return Math.sqrt((Role.xAdress-findLattice.getxAddress())*(Role.xAdress-findLattice.getxAddress())
                +(Role.yAdress-findLattice.getyAddress())*(Role.yAdress-findLattice.getyAddress()));
    }


    private static void setUp(Map map) {
        ArrayList<Lattice> lattices = map.getMap();
        if (Role.yAdress - 1 < 0) {
            System.out.println("你已经到达边界   向上移动失败！");
            return;
        }
        //将路过的格子设置为空格子
        lattices.get(Role.index).setClasszz(Map.LATTICE);
        lattices.get(Role.index).setValue(Map.setValue(Map.isNull));
        //将移动后的位子更改为角色格子
        //检测这个格子里面有什么东西
        isArticle(map,Role.index - map.getLie());
        //记录在历史记录中
        HistoryRecord.getHistory().add( lattices.get(Role.index - map.getLie()));
        lattices.get(Role.index - map.getLie()).setClasszz(Map.ROLE);
        lattices.get(Role.index - map.getLie()).setValue(Map.setValue(Map.isROLE));
        //当前角色坐标 - 地图行数 = 角色向上移动的坐标
        Role.index = Role.index - map.getLie();
        //角色的Y坐标减一向上移动
        Role.yAdress--;
        //角色方位向前走时不更改

        //移动结束，判断角色情况
        monitor();
        //扫描再6的范围内是否有怪兽
        if (findMonsters(map, 6) != null&&findMonsters(map, 6).size() !=0) {
            if (findMonsters(map, 3) != null&&findMonsters(map, 6).size() !=0) {
                //如果再3范围内有怪物，那么游戏结束
                ArrayList<Lattice> spaceLattice = findMonsters(map, 3);
                for (Lattice lattice : spaceLattice) {
                    if (lattice.getDirection() == Direction.getPostion(Role.direction, Direction.SOUTH)
                            || lattice.getDirection() == Direction.getPostion(Role.direction, Direction.EAST)
                            || lattice.getDirection() == Direction.getPostion(Role.direction, Direction.WEST)) {
                        System.out.println("怪物再你3范围内并且面对你，你的游戏结束了！\n怪物信息为： \n");
                        System.out.print(lattice.toString());
                        System.exit(0);
                    }
                }
            }
            System.out.println("怪物就在附近！小心！数量：" + findMonsters(map, 6).size() + " 个");
        }

    }

    private static void setDOWN(Map map) {
        ArrayList<Lattice> lattices = map.getMap();
        if (Role.yAdress + 1 > map.getRow()) {
            System.out.println("你已经到达边界   向下移动失败！");
            return;
        }
        //将路过的格子设置为空格子
        lattices.get(Role.index).setClasszz(Map.LATTICE);
        lattices.get(Role.index).setValue(Map.setValue(Map.isNull));
        //将移动后的位子更改为角色格子
        //检测这个格子里面有什么东西
        isArticle(map,Role.index + map.getLie());
        //记录在历史记录中
        HistoryRecord.getHistory().add( lattices.get(Role.index + map.getLie()));
        lattices.get(Role.index + map.getLie()).setClasszz(Map.ROLE);
        lattices.get(Role.index + map.getLie()).setValue(Map.setValue(Map.isROLE));
        //当前角色坐标 - 地图行数 = 角色向上移动的坐标
        Role.index = Role.index + map.getLie();
        //角色的Y坐标减一向上移动
        Role.yAdress++;
        //角色方位向后走时更改
        Role.direction = Direction.getPostion(Role.direction, Direction.SOUTH);
        lattices.get(Role.index).setDirection(Role.direction);
        //移动结束，判断角色情况
        monitor();
        //扫描再6的范围内是否有怪兽
        if (findMonsters(map, 6) != null&&findMonsters(map, 6).size() !=0) {
            if (findMonsters(map, 3) != null&&findMonsters(map, 3).size() !=0) {
                //如果再3范围内有怪物，那么游戏结束
                ArrayList<Lattice> spaceLattice = findMonsters(map, 3);
                for (Lattice lattice : spaceLattice) {
                    if (lattice.getDirection() == Direction.getPostion(Role.direction, Direction.SOUTH)
                            || lattice.getDirection() == Direction.getPostion(Role.direction, Direction.EAST)
                            || lattice.getDirection() == Direction.getPostion(Role.direction, Direction.WEST)) {
                        System.out.println("怪物再你3范围内并且面对你，你的游戏结束了！\n怪物信息为： \n");
                        System.out.print(lattice.toString());
                        System.exit(0);
                    }
                }
            }
            System.out.println("怪物就在附近！小心！数量：" + findMonsters(map, 6).size() + " 个");
        }
    }

    private static void setLEFT(Map map) {
        ArrayList<Lattice> lattices = map.getMap();
        if (Role.xAdress - 1 < 0) {
            System.out.println("你已经到达边界   向左移动失败！");
            return;
        }
        //将路过的格子设置为空格子
        lattices.get(Role.index).setClasszz(Map.LATTICE);
        lattices.get(Role.index).setValue(Map.setValue(Map.isNull));
        //将移动后的位子更改为角色格子
        //检测这个格子里面有什么东西
        isArticle(map,Role.index - 1);
        //记录在历史记录中
        HistoryRecord.getHistory().add( lattices.get(Role.index-1));

        lattices.get(Role.index - 1).setClasszz(Map.ROLE);
        lattices.get(Role.index - 1).setValue(Map.setValue(Map.isROLE));
        //当前角色坐标 - 地图行数 = 角色向上移动的坐标
        Role.index = Role.index - 1;
        //角色的Y坐标减一向上移动
        Role.xAdress--;
        //角色方位向后走时更改
        Role.direction = Direction.getPostion(Role.direction, Direction.EAST);
        lattices.get(Role.index).setDirection(Role.direction);
        //移动结束，判断角色情况
        monitor();
        //扫描再6的范围内是否有怪兽
        if (findMonsters(map, 6) != null&&findMonsters(map, 6).size() !=0) {
            if (findMonsters(map, 3) != null&&findMonsters(map, 3).size() !=0) {
                //如果再3范围内有怪物，那么游戏结束
                ArrayList<Lattice> spaceLattice = findMonsters(map, 3);
                for (Lattice lattice : spaceLattice) {
                    if (lattice.getDirection() == Direction.getPostion(Role.direction, Direction.SOUTH)
                            || lattice.getDirection() == Direction.getPostion(Role.direction, Direction.EAST)
                            || lattice.getDirection() == Direction.getPostion(Role.direction, Direction.WEST)) {
                        System.out.println("怪物再你3范围内并且面对你，你的游戏结束了！\n怪物信息为： \n");
                        System.out.print(lattice.toString());
                        System.exit(0);
                    }
                }
            }
            System.out.println("怪物就在附近！小心！数量：" + findMonsters(map, 6).size() + " 个");
        }
    }

    private static void setRIGHT(Map map) {
        ArrayList<Lattice> lattices = map.getMap();
        if (Role.xAdress + 1 > map.getLie()) {
            System.out.println("你已经到达边界   向右移动失败！");
            return;
        }

        //将路过的格子设置为空格子
        lattices.get(Role.index).setClasszz(Map.LATTICE);
        lattices.get(Role.index).setValue(Map.setValue(Map.isNull));
        //将移动后的位子更改为角色格子
        //检测这个格子里面有什么东西
        isArticle(map,Role.index + 1);
        //记录在历史记录中
        HistoryRecord.getHistory().add( lattices.get(Role.index + 1));

        lattices.get(Role.index + 1).setClasszz(Map.ROLE);
        lattices.get(Role.index + 1).setValue(Map.setValue(Map.isROLE));
        //当前角色坐标 - 地图行数 = 角色向上移动的坐标
        Role.index = Role.index + 1;
        //角色的Y坐标减一向上移动
        Role.xAdress++;
        //角色方位向后走时更改
        Role.direction = Direction.getPostion(Role.direction, Direction.WEST);
        lattices.get(Role.index).setDirection(Role.direction);
        //移动结束，判断角色情况
        monitor();
        //扫描再6的范围内是否有怪兽
        if (findMonsters(map, 6) != null&&findMonsters(map, 6).size() !=0) {
            if (findMonsters(map, 3) != null&&findMonsters(map, 3).size() !=0) {
                //如果再3范围内有怪物，那么游戏结束
                ArrayList<Lattice> spaceLattice = findMonsters(map, 3);
                for (Lattice lattice : spaceLattice) {
                    if (lattice.getDirection() == Direction.getPostion(Role.direction, Direction.SOUTH)
                            || lattice.getDirection() == Direction.getPostion(Role.direction, Direction.EAST)
                            || lattice.getDirection() == Direction.getPostion(Role.direction, Direction.WEST)) {
                        System.out.println("怪物再你3范围内并且面对你，你的游戏结束了！\n怪物信息为： \n");
                        System.out.print(lattice.toString());
                        System.exit(0);
                    }
                }
            }
            System.out.println("怪物就在附近！小心！数量：" + findMonsters(map, 6).size() + " 个");
        }
    }

    /**
     * 角色情况监听器
     * 每次移动都更新一次
     *
     * @return
     */
    private static void monitor() {
        if (Role.index == Dragon.index) {
            System.out.println("恭喜你，你已经到达终点，游戏结束！");
            System.exit(0);
        }
        //走四步减去一个食物值
        if(HistoryRecord.getHistory().size()%4==0){
            if (--Role.food < 0) {
                System.out.println("食物已经使用完，未达到终点，游戏结束！");
                System.exit(0);
            }
        }
    }

    /**
     * 执行射击命令过后，检测角色子弹，若无子弹，游戏结束
     */
    private static void shooting() {
        if (--Role.bullet < 0) {
            System.out.println("子弹已经使用完，未达到终点，游戏结束！");
            System.exit(0);
        }
    }

    /**
     * 扫描周围的怪物
     *
     * @param space 扫描范围
     * @param map   要扫描的地图
     * @return 在这个范围内是否有怪物
     */
    private static ArrayList<Lattice> findMonsters(Map map, int space) {
        ArrayList<Lattice> spaceLattice = new ArrayList<>();
        ArrayList<Lattice> lattices = map.getMap();

        //首先判断角色所在位置，确定扫描确切位置
        int upBoundary, downBoundary, leftBoundary, rightBoundary;
        if (Role.xAdress - space < 0) {
            leftBoundary = 0;
        } else {
            leftBoundary = Role.xAdress - space;
        }
        if (Role.xAdress + space > map.getLie()) {
            rightBoundary = map.getLie();
        } else {
            rightBoundary = Role.xAdress + space;
        }
        if (Role.yAdress - space < 0) {
            upBoundary = 0;
        } else {
            upBoundary = Role.yAdress - space;
        }
        if (Role.yAdress + space > map.getRow()) {
            downBoundary = map.getRow();
        } else {
            downBoundary = Role.yAdress + space;
        }

        //开始扫描角色周围的怪物
        int start = upBoundary*map.getLie() + leftBoundary;
//        System.out.println("start : " + start);
        for (int i = 0; i < downBoundary - upBoundary; i++) {
//            System.out.println("扫描第一行 ; ");
            for (int j = start; j <start+(rightBoundary - leftBoundary); j++) {

                //如果这个格子的值为怪兽 则添加到数组，返回这个范围内的所有怪物
//                System.out.println("第 " + i +" 行 第 " + j + " 列 的value为 : " + lattices.get(j).getValue()
//                        .substring(1,7).replaceAll(" ","").toUpperCase()
//                        +" ----  MONSTER 的 value 为 " +
//                        Map.setValue(Map.MONSTER).replaceAll(" ","").toUpperCase());
//                System.out.println(lattices.get(j).getValue()
//                        .substring(1,8).replaceAll(" ","").toUpperCase()
//                        .equals(Map.setValue(Map.MONSTER).replaceAll(" ","").toUpperCase()));

                if (lattices.get(j).getValue()
                        .substring(1,8).replaceAll(" ","").toUpperCase()
                        .equals(Map.setValue(Map.MONSTER).replaceAll(" ","").toUpperCase())) {
                    spaceLattice.add(lattices.get(j));
                }
            }
            start = start + map.getLie();
        }
//        System.out.println("SPACELATTICE size : ----> " + spaceLattice.size());
        return spaceLattice;
    }

    /**
     * 检测当前格子有什么道具，如果有则捡起
     *
     * @param map
     */
    private static void isArticle(Map map,int serchIndex) {
        ArrayList<Lattice> lattices = map.getMap();

        //对字符串取有效值和去空
        String LatticeValue = lattices.get(serchIndex).getValue()
                .substring(1,7).replaceAll(" ","").toUpperCase();

        if (LatticeValue.equals(Map.setValue(Map.FOOD).replaceAll(" ","").toUpperCase())) {
            System.out.println("你捡起了食物 food  +1");
            Role.food++;
        }
        if (LatticeValue.equals(Map.setValue(Map.BULLET).replaceAll(" ","").toUpperCase())) {
            System.out.println("你捡起了子弹 bullet  +1");
            Role.bullet++;
        }
    }

}
